import { request, getFullImageUrl, initBaseUrl } from '../../../utils/request';
import { uploadFile } from '@/utils/request';

export default {
	data() {
		return {
			// 头像
			avatarUrl: '',
			tempFilePath: '',
			// 资料字段
			inputNickname: '', // 输入的昵称
			nickname: '', // 显示的昵称
			showError: false, // 新增变量，用于控制错误提示显示
			timer: null, // 新增定时器变量
			showGenderPopup: false,
			selectedGender: '',
			isEditingAge: false,
			isEditingHeight: false,
			tempAge: '', // 临时存储年龄编辑值
			tempHeight: '', // 临时存储身高编辑值
			age: '',
			height: '',
			selfDesc: '', // 自我描述内容临时变量
			displaySelfDesc: '', // 显示的自我描述内容
			job: '', // 页面显示用变量
			jobValue: '', // 弹窗编辑用临时变量
			selectedSkills: [],
			skills: [], // 存储所有添加的技能 {name: string, selected: boolean}
			isEditing: false, // 控制编辑删除模式
			maxSelected: 6, // 最大选择数量
			maxSkills: 10, // 最大添加数量
			editSkillValue: '',
			time: '工作日 00:00 - 00:00',
			hasDefaultTime: false, // 新增标志位，表示是否包含默认时间
			selectedWeekdays: [],
			startTimeValue: '',
			endTimeValue: '',
			startTime: '00:00',
			endTime: '23:59',
			weekdays: ['周一', '周二', '周三', '周四', '周五', '周六', '周日'],
			timeList: [], // 存储所有选择的时间
			editingIndex: -1, // 当前编辑的索引，-1表示新增
			isConfirmEnabled: false,
			isAddConfirmEnabled: false,
			area: '',
			acceptArea: {
				address: '',
				rangeIndex: 2, // 默认选中"定位中心10公里"
				latitude: '',
				longitude: ''
			},
			rangeOptions: ['全市', '全区', '定位中心10公里', '定位中心5公里'],
			cuisineDesc: '', // 擅长菜系内容
			// 认证状态
			authStatus: false,
			wechatBound: false,
			wechatUserInfo: null, // 存储微信用户信息
			alipayBound: false,
			isConfirmEnabled: false, // 控制确认按钮状态
			isAddConfirmEnabled: false, // 控制添加时间确认按钮状态
			timeList: [], // 存储所有选择的时间
			debounceTimer: null, // 防抖定时器
			isSubmitting: false, // 提交状态锁
			pendingUpdates: {} // 待提交的更新字段
		};
	},
	computed: {
		isSaveEnabled() {
			return this.timeList.length > 0;
		},
		isSaveAreaEnabled() {
			// 地址不为空且已选择位置时启用保存按钮
			return this.acceptArea.address.trim() !== ''
		}
	},
	onLoad() {
		// this.checkWechatBind();
		// 从本地存储读取技能数据
		// const storedSkills = uni.getStorageSync('userSkills');
		// if (storedSkills && storedSkills.length > 0) {
		// 	this.skills = storedSkills;
		// } else {
		// 	// 初始化默认技能（如果需要）
		// 	this.skills = [];
		// }
		// 新增：获取用户信息
		initBaseUrl();
		this.getUserInfo();

		// 添加事件总线监听器，接收位置更新数据
		this.$bus.$on('locationUpdated', this.updateAddress);
	},

	onUnload() {
		// 移除事件总线监听器，避免内存泄漏
		this.$bus.$off('locationUpdated', this.updateAddress);
	},
	// async onShow() {
	// 	await this.getUserInfo();
	// },
	methods: {

		getFullImageUrl,

		// 防抖处理函数
		debounce(func, delay = 500) {
			return (...args) => {
				if (this.debounceTimer) clearTimeout(this.debounceTimer);
				this.debounceTimer = setTimeout(() => {
					func.apply(this, args);
				}, delay);
			};
		},

		// 通用字段更新方法
		updateUserField(field, value) {
			// 记录待更新字段
			this.pendingUpdates[field] = value;

			// 防抖提交
			this.debounce(this.submitPendingUpdates)();
		},

		// 提交待更新字段
		async submitPendingUpdates() {
			if (this.isSubmitting || Object.keys(this.pendingUpdates).length === 0) return;

			this.isSubmitting = true;
			const updateData = { ...this.pendingUpdates };
			this.pendingUpdates = {}; // 清空待提交队列

			try {
				const res = await request({
					url: '/User/edit',
					method: 'GET',
					data: updateData
				});

				if (res.code === 200 && res.data) {
					uni.showToast({
						title: '保存成功',
						icon: 'success',
						duration: 1500
					});
					// 更新本地存储
					const userInfo = uni.getStorageSync('userInfo') || {};
					uni.setStorageSync('userInfo', { ...userInfo, ...updateData });
				} else {
					uni.showToast({
						title: '保存失败: ' + (res.data.message || '未知错误'),
						icon: 'none',
						duration: 2000
					});
					// 恢复待提交字段以便重试
					this.pendingUpdates = { ...this.pendingUpdates, ...updateData };
				}
			} catch (err) {
				console.error('提交更新失败:', err);
				uni.showToast({
					title: '网络错误，请稍后重试',
					icon: 'none',
					duration: 2000
				});
				// 恢复待提交字段以便重试
				this.pendingUpdates = { ...this.pendingUpdates, ...updateData };
			} finally {
				this.isSubmitting = false;
			}
		},

		// 返回上一页
		onBack() {
			uni.navigateBack();
		},
		// 打开修改头像弹窗
		openAvatarPopup() {
			this.$refs.avatarPopup.open();
		},
		// 关闭修改头像弹窗
		closeAvatarPopup() {
			this.$refs.avatarPopup.close();
		},
		// 上传头像
		chooseImage(sourceType) {
			uni.chooseImage({
				count: 1,
				sizeType: ['original', 'compressed'],
				sourceType: [sourceType],
				success: (res) => {
					console.log('选择图片成功', res);
					this.tempFilePath = res.tempFilePaths[0];
					console.log('选择的图片路径', this.tempFilePath);
					this.closeAvatarPopup();
					uploadFile({
						url: '/Common/uploadLocalOnly', // 后端上传接口
						filePath: this.tempFilePath,
						name: 'file',
						success: (uploadRes) => {
							try {
								console.log('上传接口返回原始数据:', uploadRes.data); // 新增日志，查看原始返回数据
								// 检查是否是有效的JSON格式
								if (uploadRes.data && (uploadRes.data.startsWith('{') || uploadRes.data.startsWith('['))) {
									const result = JSON.parse(uploadRes.data);
									console.log('上传结果', result);
									if (result.code === 1) {
										const avatarUrl = result.data.fullurl; // 后端返回的图片URL
										this.avatarUrl = avatarUrl;
										this.updateUserField('avatar', avatarUrl); // 更新用户信息
										console.log('头像上传成功', avatarUrl);
									} else {
										// 显示后端返回的错误信息
										uni.showToast({
											title: result.msg || '上传失败',
											icon: 'none',
											duration: 2000
										});
										return; // 上传失败，直接返回
									}
								} else {
									console.error('上传结果不是有效的JSON格式', uploadRes.data);
								}
							} catch (e) {
								console.error('解析上传结果失败', e, '返回数据:', uploadRes.data);
							}
						},
						fail: (err) => {
							console.log('上传接口调用失败', err);
						}
					});
				},
				fail: (err) => {
					console.log('选择图片失败', err);
					this.closeAvatarPopup();
				}
			});
		},
		// 打开编辑昵称弹窗
		openNicknamePopup() {
			this.$refs.nicknamePopup.open();
		},
		// 输入事件处理
		handleInput() {
			// 清除之前的定时器，避免多次触发
			if (this.timer) {
				clearTimeout(this.timer);
			}

			// 实时判断输入长度
			if (this.inputNickname.length > 5) {
				this.showError = true; // 超过 5 个字符显示错误提示

				// 设置3秒后自动隐藏错误提示
				this.timer = setTimeout(() => {
					this.showError = false;
					this.timer = null; // 清除定时器引用
				}, 3000);
			} else {
				this.showError = false; // 未超过隐藏错误提示
			}
		},
		// 保存
		handleSave() {
			// 清除之前的定时器
			if (this.timer) {
				clearTimeout(this.timer);
			}

			if (this.inputNickname.length > 5) {
				this.showError = true;

				// 设置3秒后自动隐藏错误提示
				this.timer = setTimeout(() => {
					this.showError = false;
					this.timer = null;
				}, 3000);

				return;
			}
			if (this.inputNickname.trim()) {
				this.nickname = this.inputNickname;
				this.$refs.nicknamePopup.close();
				// 即时提交更新
				this.updateUserField('nickname', this.nickname);
			}
		},
		// 取消
		handleCancel() {
			this.inputNickname = '';
			this.showError = false;
			this.$refs.nicknamePopup.close();
		},



		// 打开性别选择弹框
		openGenderPopup() {
			this.$refs.genderPopup.open();
		},
		// 选择性别
		selectGender(gender) {
			this.selectedGender = gender;
			this.$refs.genderPopup.close();
			// 即时提交更新
			this.updateUserField('gender', gender === '男' ? 0 : 1);
		},
		// 关闭性别选择弹框
		closeGenderPopup() {
			this.$refs.genderPopup.close();
		},
		// 编辑年龄
		saveAge() {
			// 简单验证年龄为数字
			if (this.tempAge && !isNaN(this.tempAge)) {
				const ageNum = parseInt(this.tempAge);
				if (ageNum > 0 && ageNum < 150) {
					this.age = ageNum.toString(); // 保存为字符串显示
				} else {
					uni.showToast({
						title: '请输入1-150之间的年龄',
						icon: 'none'
					});
				}
			} else if (this.tempAge === '') {
				this.age = ''; // 允许清空
			} else {
				uni.showToast({
					title: '请输入有效的年龄',
					icon: 'none'
				});
			}
			this.isEditingAge = false;
			// 即时提交更新
			if (this.age) this.updateUserField('age', this.age);
		},

		// 编辑身高
		saveHeight() {
			// 简单验证身高为数字
			if (this.tempHeight && !isNaN(this.tempHeight)) {
				const heightNum = parseInt(this.tempHeight);
				if (heightNum > 50 && heightNum < 250) {
					this.height = heightNum.toString(); // 保存为字符串显示
				} else {
					uni.showToast({
						title: '请输入50-250之间的身高',
						icon: 'none'
					});
				}
			} else if (this.tempHeight === '') {
				this.height = ''; // 允许清空
			} else {
				uni.showToast({
					title: '请输入有效的身高(cm)',
					icon: 'none'
				});
			}
			this.isEditingHeight = false;
			// 即时提交更新
			if (this.height) this.updateUserField('height', this.height);
		},


		// 打开编辑自我描述弹窗
		openSelfDescPopup() {
			this.selfDesc = this.displaySelfDesc;
			this.$refs.selfDescPopup.open();
		},
		// 保存
		handleSaveDesc() {
			if (this.selfDesc.trim()) {
				this.displaySelfDesc = this.selfDesc;
				// 这里可调用接口上传自我描述，示例仅打印
				console.log('自我描述内容：', this.selfDesc);
				this.$refs.selfDescPopup.close();
				// 即时提交更新
				this.updateUserField('bio', this.displaySelfDesc);
			} else {
				// 可提示内容不能为空，这里简单处理
				console.log('自我描述内容不能为空');
			}
		},
		// 取消
		handleCancelDesc() {
			this.selfDesc = '';
			this.$refs.selfDescPopup.close();
		},

		// 编辑主工作职业
		openJobPopup() {
			this.jobValue = this.job;
			this.$refs.jobPopup.open();
		},
		closeJobPopup() {

			this.$refs.jobPopup.close();
		},
		onJobPopupChange(e) {

			console.log('popup change', e);
		},
		saveJob() {
			if (this.jobValue.trim()) {
				this.job = this.jobValue;
				// 保存职业逻辑
				console.log('保存职业：', this.jobValue);
				this.closeJobPopup();
				// 即时提交更新
				this.updateUserField('main_job', this.job);
			}
		},

		// 编辑技能描述
		// 打开技能弹窗时初始化数据
		openSkillPopup() {
			// 如果是首次打开，初始化技能数据
			if (!this.skills || this.skills.length === 0) {
				this.skills = [];
			}
			this.$refs.skillPopup.open();
		},
		openEditSkill() {
			this.editSkillValue = '';
			this.$refs.editSkillPopup.open();
		},
		closeEditSkill() {
			this.editSkillValue = '';
			this.$refs.editSkillPopup.close();
		},
		// 确认添加技能
		confirmEditSkill() {
			if (this.editSkillValue.trim() && this.skills.length < this.maxSkills) {
				const exists = this.skills.some(skill => skill.name === this.editSkillValue.trim());
				if (!exists) {
					this.skills.push({
						name: this.editSkillValue.trim(),
						selected: false
					});
					// 保存到本地存储
					uni.setStorageSync('userSkills', this.skills);
					this.editSkillValue = '';
					this.closeEditSkill();
				} else {
					uni.showToast({
						title: '该技能已添加',
						icon: 'none'
					});
				}
			}
		},

		// 标签选择切换
		toggleSelect(index) {
			const skill = this.skills[index];
			// 如果未选中且已达最大选择数，提示并返回
			if (!skill.selected && this.skills.filter(s => s.selected).length >= this.maxSelected) {
				uni.showToast({
					title: '最多只能选择6个技能',
					icon: 'none'
				});
				return;
			}
			skill.selected = !skill.selected;
		},
		// 修改删除技能方法
		removeSkill(index) {
			this.skills.splice(index, 1);
		},

		// 保存技能
		saveSkills() {
			// 修复：保存所有技能状态而非仅选中的技能
			const allSkills = [...this.skills];
			this.isEditing = false;

			// 更新选中的技能数组
			this.selectedSkills = allSkills.filter(skill => skill.selected);

			if (this.selectedSkills.length === 0) {
				uni.showToast({ title: '请至少选择一个技能', icon: 'none' });
				return;
			}

			this.closePopup('skill');
			// 保存完整的技能数组到后端
			this.updateUserField('skill_description', JSON.stringify(allSkills));
			uni.showToast({ title: '技能保存成功', icon: 'success' });
			// 更新本地存储
			uni.setStorageSync('userSkills', allSkills);
		},
		closePopup(type) {
			if (type === 'skill') {
				this.$refs.skillPopup.close();
			}
		},
		onPopupChange(e) {
			console.log('popup change', e);
		},

		// 打开编辑可兼职时间弹窗
		openEditPopup() {
			// 如果timeList为空，但time有默认值，初始化timeList
			if (this.timeList.length === 0 && this.time === '工作日 00:00 - 00:00') {
				this.timeList.push(this.time);
				this.hasDefaultTime = true; // 标记有默认时间
			}
			this.$refs.editPopup.open();
		},

		// 打开编辑时间弹窗
		openEditTime(index) {
			this.editingIndex = index;
			const timeStr = this.timeList[index];

			// 检查是否是默认文本
			if (timeStr === '工作日 00:00 - 00:00') {
				this.selectedWeekdays = [];
				this.startTimeValue = '';
				this.endTimeValue = '';
			} else {
				try {
					// 使用正则表达式更健壮地解析时间字符串
					const daysMatch = timeStr.match(/^(.*?)\s+(\d{2}:\d{2})\s*-\s*(\d{2}:\d{2})$/);
					if (daysMatch && daysMatch.length === 4) {
						// 解析工作日
						this.selectedWeekdays = daysMatch[1].split('、');

						// 设置时间
						this.startTimeValue = daysMatch[2];
						this.endTimeValue = daysMatch[3];
					} else {
						// 如果正则匹配失败，尝试传统的分割方式
						const parts = timeStr.split(' ');
						if (parts.length >= 3) {
							// 合并前面所有部分作为工作日
							const daysPart = parts.slice(0, parts.length - 2).join(' ');
							this.selectedWeekdays = daysPart.split('、');
							
							// 解析时间部分
							const timePart = parts[parts.length - 2] + ' ' + parts[parts.length - 1];
							const [startTime, endTime] = timePart.split(' - ');
							this.startTimeValue = startTime || '';
							this.endTimeValue = endTime || '';
						} else {
							// 无法解析时设置默认值
							this.selectedWeekdays = [];
							this.startTimeValue = '';
							this.endTimeValue = '';
						}
					}
				} catch (error) {
					console.error('解析时间失败:', error);
					// 出错时设置安全的默认值
					this.selectedWeekdays = [];
					this.startTimeValue = '';
					this.endTimeValue = '';
				}
			}

			// 更新确认按钮状态
			this.updateConfirmButton();

			this.$refs.timePopup.open();
		},


		// 打开添加时间弹窗
		openAddTime() {
			this.editingIndex = -1; // 表示新增
			this.selectedWeekdays = [];
			this.startTimeValue = '';
			this.endTimeValue = '';
			this.updateConfirmButton();
			this.$refs.timePopup.open();
		},

		// 切换工作日选择
		toggleWeekday(day) {
			const index = this.selectedWeekdays.indexOf(day);
			if (index !== -1) {
				this.selectedWeekdays.splice(index, 1);
			} else {
				this.selectedWeekdays.push(day);
			}
			this.updateConfirmButton();
		},
		// 开始时间变化
		onStartTimeChange(e) {
			this.startTimeValue = e.detail.value;
			// 如果开始时间大于结束时间，清空结束时间
			if (this.endTimeValue && this.startTimeValue > this.endTimeValue) {
				this.endTimeValue = '';
			}
			this.updateConfirmButton();
		},

		// 结束时间变化
		onEndTimeChange(e) {
			this.endTimeValue = e.detail.value;
			this.updateConfirmButton();
		},

		// 更新确认按钮状态
		updateConfirmButton() {
			if (this.editingIndex >= 0) {
				// 编辑模式下，只要用户修改了工作日或时间，就启用确认按钮
				// 但仍然需要确保有有效的选择
				this.isConfirmEnabled = (this.selectedWeekdays.length > 0 || 
					this.startTimeValue || 
					this.endTimeValue);
			} else {
				// 新增模式下，需要用户选择了有效的工作日和时间
				this.isConfirmEnabled = this.selectedWeekdays.length > 0 &&
					this.startTimeValue &&
					this.endTimeValue;
			}
		},

		// 确认时间选择
		confirmTime() {
			if (!this.isConfirmEnabled) return;

			// 定义工作日的固定顺序
			const weekdayOrder = ['周一', '周二', '周三', '周四', '周五', '周六', '周日'];

			// 对选中的工作日进行排序的函数
			const sortWeekdays = (weekdays) => {
				return weekdays.sort((a, b) => {
					return weekdayOrder.indexOf(a) - weekdayOrder.indexOf(b);
				});
			};

			let timeStr;
			if (this.editingIndex >= 0) {
				// 编辑模式下，优先检查是否有新的选择
				if (this.selectedWeekdays.length > 0 && this.startTimeValue && this.endTimeValue) {
					// 对选中的工作日进行排序
					const sortedWeekdays = sortWeekdays([...this.selectedWeekdays]);
					const daysStr = sortedWeekdays.join('、');
					timeStr = `${daysStr} ${this.startTimeValue} - ${this.endTimeValue}`;
				} else if (this.selectedWeekdays.length > 0 || this.startTimeValue || this.endTimeValue) {
					// 如果只修改了工作日或时间中的一部分，获取原时间的未修改部分
					const originalTime = this.timeList[this.editingIndex];
					let daysStr;
					if (this.selectedWeekdays.length > 0) {
						// 对选中的工作日进行排序
						const sortedWeekdays = sortWeekdays([...this.selectedWeekdays]);
						daysStr = sortedWeekdays.join('、');
					} else {
						daysStr = originalTime.match(/(.+?) \d{2}:\d{2} - \d{2}:\d{2}/)[1];
					}
					const startTime = this.startTimeValue || originalTime.match(/(\d{2}:\d{2}) - \d{2}:\d{2}/)[1];
					const endTime = this.endTimeValue || originalTime.match(/\d{2}:\d{2} - (\d{2}:\d{2})/)[1];
					timeStr = `${daysStr} ${startTime} - ${endTime}`;
				} else {
					// 如果没有做任何修改，保留原时间
					timeStr = this.timeList[this.editingIndex];
				}
			} else {
				// 新增模式下，必须有有效选择
				if (this.selectedWeekdays.length > 0 && this.startTimeValue && this.endTimeValue) {
					// 对选中的工作日进行排序
					const sortedWeekdays = sortWeekdays([...this.selectedWeekdays]);
					const daysStr = sortedWeekdays.join('、');
					timeStr = `${daysStr} ${this.startTimeValue} - ${this.endTimeValue}`;
				} else {
					console.error('无法保存时间：请选择工作日和时间');
					return;
				}
			}

			// 更新或添加时间项
			if (this.editingIndex >= 0) {
				this.timeList[this.editingIndex] = timeStr;
				// 如果编辑的是默认时间，更新标志位
				if (this.timeList[this.editingIndex] !== '工作日 00:00 - 00:00') {
					this.hasDefaultTime = false;
				}
			} else {
				this.timeList.push(timeStr);
			}

			// 更新显示文本
			this.time = this.timeList.join('; ');
 
			// 如果替换了默认文本，确保timeList中不再包含它
			if (this.timeList.length > 1) {
				this.timeList = this.timeList.filter(item => item !== '工作日 00:00 - 00:00');
				this.time = this.timeList.join('; ');
			}

			// 关闭弹窗
			this.$refs.timePopup.close();
		},

		// 保存所有更改 - 只要用户修改了就可以保存
		saveChanges() {
			// 过滤掉默认的空时间段
			this.timeList = this.timeList.filter(item => item !== '工作日 00:00 - 00:00');

			// 如果没有有效时间段，保留一个默认项
			if (this.timeList.length === 0) {
				this.timeList.push('工作日 00:00 - 00:00');
				this.hasDefaultTime = true;
			} else {
				this.hasDefaultTime = false;
			}

			this.time = this.timeList.join('; ');
			console.log('保存的时间：', this.timeList);
			// 即时提交更新
			this.updateUserField('part_time', this.timeList);
			uni.showToast({ title: '保存成功', icon: 'success' });
			this.$refs.editPopup.close();
		},

		// 取消编辑
		cancelEdit() {
			this.$refs.editPopup.close();
			this.$refs.timePopup.close();
		},

		// 关闭时间选择弹窗
		closeTimePopup() {
			this.$refs.timePopup.close();
		},


		closeAddTimePopup() {
			this.$refs.addTimePopup.close();
		},
		onPopupChange(e) {
			console.log('弹窗状态变化：', e);
		},
		// 开始时间选择
		onStartTimeChange(e) {
			this.startTimeValue = e.detail.value;
			// 如果开始时间大于结束时间，清空结束时间
			if (this.endTimeValue && this.startTimeValue > this.endTimeValue) {
				this.endTimeValue = '';
			}
			this.updateConfirmButton();
		},
		// 结束时间变化
		onEndTimeChange(e) {
			this.endTimeValue = e.detail.value;
			this.updateConfirmButton();
		},


		// 接收从map-page传递的地址和经纬度数据
		updateAddress(locationData) {
			console.log('接收到的位置数据:', locationData);
			if (locationData && typeof locationData === 'object') {
				this.acceptArea = {
					...this.acceptArea,
					address: locationData.address,
					latitude: locationData.latitude,
					longitude: locationData.longitude
				};
				console.log('更新位置信息:', this.acceptArea);
			}
		},

		// 打开区域编辑弹窗
		openAreaPopup() {
			this.$refs.areaPopup.open();
			// 调用Vuex位置获取方法
			if (!this.acceptArea.address) {
				try {
					this.$store.dispatch('location/getLocation')
						.then(address => {
							this.acceptArea.address = address
						})
				} catch (err) {
					console.error('获取位置失败', err)
				}
			}
		},
		// 关闭区域编辑弹窗
		closeAreaPopup() {
			this.$refs.areaPopup.close();
		},
		// 跳转到位置选择页面
		navigateToLocationSelect() {
			uni.navigateTo({
				url: '/pages/release/map-page?from=personalData'
			});
		},
		// 范围选择变化
		onRangeChange(e) {
			this.acceptArea.rangeIndex = e.detail.value;
			console.log('范围选择变化：', e.detail.value);
		},
		// 保存区域设置
		async saveAreaChanges() {
			if (!this.isSaveAreaEnabled) return;
			console.log('保存区域设置：', this.acceptArea);
			// 即时提交更新
			this.updateUserField('acceptable_area', this.acceptArea.address);
			this.updateUserField('acceptable_lat', this.acceptArea.latitude);
			this.updateUserField('acceptable_lng', this.acceptArea.longitude);
			this.updateUserField('acceptable_km', this.rangeOptions[this.acceptArea.rangeIndex]);

			uni.showToast({ title: '保存成功', icon: 'success' });
			this.closeAreaPopup();
		},




		// 编辑擅长菜系弹窗
		openCuisinePopup() {
			this.$refs.cuisinePopup.open();
		},
		// 处理输入事件
		handleCuisineInput(e) {
			this.cuisineDesc = e.detail.value;
		},
		// 保存擅长菜系
		handleCuisineSave() {
			if (this.cuisineDesc.trim().length > 0) {
				this.updateUserField('specializes_cuisine', this.cuisineDesc);
				uni.showToast({ title: '保存成功', icon: 'success' });
				this.$refs.cuisinePopup.close();
			} else {
				uni.showToast({ title: '请填写内容', icon: 'none' });
			}
		},
		// 处理取消按钮点击
		handleCuisineCancel() {
			this.$refs.cuisinePopup.close();
		},
		// 实名认证
		onAuth() {
			if (!this.authStatus) {
				uni.navigateTo({
					url: '/pages/pageMy/Authn/Authn'
				});
			}
		},
		// 绑定微信
		onBindWechat() {
			if (!this.wechatBound) {
				// 调用微信登录 API（需微信开放平台配置）
				uni.showToast({
					title: '绑定中...',
					icon: 'none'
				});
				setTimeout(() => {
					this.wechatBound = true;
					uni.showToast({
						title: '绑定成功',
						icon: 'success'
					});
				}, 1500);
			}
		},


		//  // 绑定微信（真实实现）
		//  async onBindWechat() {
		// 	if (this.wechatBound) return;

		// 	uni.showLoading({
		// 	  title: '微信授权中...',
		// 	  mask: true
		// 	});

		// 	try {
		// 	  // 1. 获取微信code
		// 	  const [err, res] = await uni.login({
		// 		provider: 'weixin'
		// 	  });

		// 	  if (err) throw new Error('微信登录失败');

		// 	  // 2. 调用后端绑定接口
		// 	  const [bindErr, bindRes] = await uni.request({
		// 		url: 'https://your-domain.com/api/wechat/bind',
		// 		method: 'POST',
		// 		data: { code: res.code },
		// 		header: {
		// 		  'Content-Type': 'application/json',
		// 		  'Authorization': 'Bearer ' + this.getToken() // 如果有登录token
		// 		}
		// 	  });

		// 	  if (bindRes.statusCode !== 200 || !bindRes.data.success) {
		// 		throw new Error(bindRes.data.message || '绑定失败');
		// 	  }

		// 	  // 3. 更新绑定状态
		// 	  this.wechatBound = true;
		// 	  this.wechatUserInfo = bindRes.data.userInfo;

		// 	  uni.showToast({
		// 		title: '绑定成功',
		// 		icon: 'success'
		// 	  });

		// 	} catch (error) {
		// 	  console.error('微信绑定失败:', error);
		// 	  uni.showToast({
		// 		title: error.message || '绑定失败',
		// 		icon: 'none'
		// 	  });
		// 	} finally {
		// 	  uni.hideLoading();
		// 	}
		//   },

		//   // 检查绑定状态（可在onLoad中调用）
		//   async checkWechatBind() {
		// 	const [err, res] = await uni.request({
		// 	  url: 'https://your-domain.com/api/wechat/check-bind',
		// 	  header: {
		// 		'Authorization': 'Bearer ' + this.getToken()
		// 	  }
		// 	});

		// 	if (res.data.success) {
		// 	  this.wechatBound = res.data.bound;
		// 	  this.wechatUserInfo = res.data.userInfo;
		// 	}
		//   },

		//   getToken() {
		// 	// 从缓存获取token的实现
		// 	return uni.getStorageSync('token') || '';
		//   },

		// 绑定支付宝
		onBindAlipay() {
			if (!this.alipayBound) {
				uni.showToast({
					title: '绑定中...',
					icon: 'none'
				});
				setTimeout(() => {
					this.alipayBound = true;
					uni.showToast({
						title: '绑定成功',
						icon: 'success'
					});
				}, 1500);
			}
		},


		// 获取用户信息并赋值
		async getUserInfo() {
			try {
				const res = await request({
					url: '/User/info',
					method: 'GET'
				});

				if (res.code === 200 && res.data) {
					const userInfo = res.data;
					console.log('获取用户信息:', userInfo);

					// 基本信息赋值 - 确保所有字段正确映射
					this.avatarUrl = userInfo.avatar || '';
					this.nickname = userInfo.nickname || '';
					this.inputNickname = userInfo.nickname || '';
					this.selectedGender = userInfo.gender === 0 ? '男' : userInfo.gender === 1 ? '女' : '';
					this.age = userInfo.age ? userInfo.age.toString() : '';
					this.height = userInfo.height ? userInfo.height.toString() : '';
					this.displaySelfDesc = userInfo.bio || '';
					this.selfDesc = userInfo.bio || '';
					this.job = userInfo.main_job || '';
					this.jobValue = userInfo.main_job || '';
					this.cuisineDesc = userInfo.specializes_cuisine || '';
					this.authStatus = userInfo.realname_verified ? true : false;


					if (userInfo.skill_description) {
						try {
							// 解析后端返回的JSON字符串为数组
							this.skills = JSON.parse(userInfo.skill_description);
							// 筛选出selected为true的技能用于页面显示
							this.selectedSkills = this.skills.filter(skill => skill.selected);
						} catch (e) {
							console.error('解析技能数据失败:', e);
							this.skills = [];
							this.selectedSkills = [];
						}
					}

					// 地址信息处理
					this.acceptArea = {
						...this.acceptArea,
						address: userInfo.acceptable_area || '',
						latitude: userInfo.acceptable_lat || '',
						longitude: userInfo.acceptable_lng || '',
						rangeIndex: userInfo.acceptable_km ?
							this.rangeOptions.indexOf(userInfo.acceptable_km) : 2
					};

					// 可兼职时间处理
					if (userInfo.part_time) {
						try {
							// 处理可能的转义字符问题
							const cleanedPartTime = userInfo.part_time.replace(/\\"/g, '"');
							this.timeList = JSON.parse(cleanedPartTime);
							this.time = this.timeList.join('; ');
							// console.log('解析后的兼职时间:', this.timeList); // 添加调试日志
						} catch (e) {
							console.error('解析part_time失败:', e);
							this.timeList = [];
						}
					}

					// 保存到本地存储
					// uni.setStorageSync('userInfo', userInfo);
				} else {
					console.error('获取用户信息失败:', res.data?.message || '未知错误');
					// 尝试从本地存储加载

				}
			} catch (err) {
				console.error('获取用户信息错误:', err);
				// 尝试从本地存储加载

			}
		},
		goBack() {
			uni.navigateBack({
				delta: 1
			});
		}

	}
};